Celestin Apprentice 4/Apprentice-Release4.iso/Languages/MPW Oberon 2.1168/OInterfaces/Movies.mod

Text File | 1995-08-10 | 85.7 KB | 2,295 lines | [TEXT/MPS ]

(*
     File:        Movies.mod

     Contains:    QuickTime Interfaces.

     Version:    Technology:    QuickTime 2.0
                 Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17

     Copyright:    © 1984-1995 by Apple Computer, Inc.
                 All rights reserved.

     Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
                 stack.  Include the file and version information (from above)
                 in the problem description and send to:
                     Internet:    apple.bugs.applelink.apple.com
                     AppleLink:    APPLE.BUGS

*)

(*$TAGS-*)
(*$CALLING PASCAL*)
MODULE Movies;

IMPORT SYSTEM, Types, Quickdraw, Files, Events, Menus, TextEdit, Dialogs,
       Components, ImageCompression;

(* $PUSH*)
(* $ALIGN MAC68K*)
(* $LibExport+*)

CONST
    MovieFileType*                = LONG("MooV");

    MediaHandlerType*            = LONG("mhlr");
    DataHandlerType*                = LONG("dhlr");

    VideoMediaType*                = LONG("vide");
    SoundMediaType*                = LONG("soun");
    TextMediaType*                = LONG("text");
    BaseMediaType*                = LONG("gnrc");
    MPEGMediaType*                = LONG("MPEG");
    MusicMediaType*                = LONG("musi");
    TimeCodeMediaType*            = LONG("tmcd");
    HandleDataHandlerSubType*    = LONG("hndl");

    VisualMediaCharacteristic*    = LONG("eyes");
    AudioMediaCharacteristic*    = LONG("ears");

    DoTheRightThing*                = 0;


TYPE
    MovieRecord* = RECORD
        data*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
    END;

    Movie* = POINTER TO MovieRecord;

    TrackRecord* = RECORD
        data*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
    END;

    Track* = POINTER TO TrackRecord;

    MediaRecord* = RECORD
        data*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
    END;

    Media* = POINTER TO MediaRecord;

    UserDataRecord* = RECORD
        data*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
    END;

    UserData* = POINTER TO UserDataRecord;

    TrackEditStateRecord* = RECORD
        data*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
    END;

    TrackEditState* = POINTER TO TrackEditStateRecord;

    MovieEditStateRecord* = RECORD
        data*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
    END;

    MovieEditState* = POINTER TO MovieEditStateRecord;

    SampleDescription* = RECORD
        descSize*:                LONGINT;
        dataFormat*:                LONGINT;
        resvd1*:                    LONGINT;
        resvd2*:                    INTEGER;
        dataRefIndex*:            INTEGER;
    END;

    SampleDescriptionPtr* = POINTER TO SampleDescription;
    SampleDescriptionHandle* = HANDLE TO SampleDescription (*ΔΔ POINTER TO SampleDescriptionPtr*);

    SoundDescription* = RECORD
        descSize*:                LONGINT;                                (* total size of SoundDescription including extra data *)
        dataFormat*:                LONGINT;                                (*  *)
        resvd1*:                    LONGINT;                                (* reserved for apple use *)
        resvd2*:                    INTEGER;
        dataRefIndex*:            INTEGER;
        version*:                INTEGER;                                (* which version is this data *)
        revlevel*:                INTEGER;                                (* what version of that codec did this *)
        vendor*:                    LONGINT;                                (* whose  codec compressed this data *)
        numChannels*:            INTEGER;                                (* number of channels of sound *)
        sampleSize*:                INTEGER;                                (* number of bits per sample *)
        compressionID*:            INTEGER;                                (* sound compression used, 0 if none *)
        packetSize*:                INTEGER;                                (* packet size for compression, 0 if no compression *)
        sampleRate*:                Types.Fixed;                                    (* sample rate sound is captured at *)
    END;

    SoundDescriptionPtr* = POINTER TO SoundDescription;
    SoundDescriptionHandle* = HANDLE TO SoundDescription (*ΔΔ POINTER TO SoundDescriptionPtr*);

    TextDescription* = RECORD
        descSize*:                LONGINT;                                (* Total size of TextDescription*)
        dataFormat*:                LONGINT;                                (* LONG("text")*)
        resvd1*:                    LONGINT;
        resvd2*:                    INTEGER;
        dataRefIndex*:            INTEGER;
        displayFlags*:            LONGINT;                                (* see enum below for flag values*)
        textJustification*:        LONGINT;                                (* Can be*: teCenter,teFlush -Default,-Right,-Left*)
        bgColor*:                Quickdraw.RGBColor;                                (* Background color*)
        defaultTextBox*:            Types.Rect;                                    (* Location to place the text within the track bounds*)
        defaultStyle*:            TextEdit.ScrpSTElement;                            (* Default style (struct defined in TextEdit.h)*)
        defaultFontName*:        (*ΔΔPACKEDΔΔ*) ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF CHAR;            (* Font Name (pascal string - struct extended to fit) *)
    END;

    TextDescriptionPtr* = POINTER TO TextDescription;
    TextDescriptionHandle* = HANDLE TO TextDescription (*ΔΔ POINTER TO TextDescriptionPtr*);

(*--------------------------
  Music Sample Description
--------------------------*)
    MusicDescription* = RECORD
        descSize*:                LONGINT;
        dataFormat*:                LONGINT;                                (* LONG("musi") *)
        resvd1*:                    LONGINT;
        resvd2*:                    INTEGER;
        dataRefIndex*:            INTEGER;
        musicFlags*:                LONGINT;
        headerData*:                ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;                (* variable size! *)
    END;

    MusicDescriptionPtr* = POINTER TO MusicDescription;

    MusicDescriptionHandle* = HANDLE TO MusicDescription (*ΔΔ POINTER TO MusicDescriptionPtr*);


CONST
    dfDontDisplay*                = ASH(1,0);                    (* Don't display the text*)
    dfDontAutoScale*                = ASH(1,1);                    (* Don't scale text as track bounds grows or shrinks*)
    dfClipToTextBox*                = ASH(1,2);                    (* Clip update to the textbox*)
    dfUseMovieBGColor*            = ASH(1,3);                    (* Set text background to movie's background color*)
    dfShrinkTextBoxToFit*        = ASH(1,4);                    (* Compute minimum box to fit the sample*)
    dfScrollIn*                    = ASH(1,5);                    (* Scroll text in until last of text is in view *)
    dfScrollOut*                    = ASH(1,6);                    (* Scroll text out until last of text is gone (if both set, scroll in then out)*)
    dfHorizScroll*                = ASH(1,7);                    (* Scroll text horizontally (otherwise it's vertical)*)
    dfReverseScroll*                = ASH(1,8);                    (* vert*: scroll down rather than up; horiz: scroll backwards (justfication dependent)*)
    dfContinuousScroll*            = ASH(1,9);                    (* new samples cause previous samples to scroll out *)
    dfFlowHoriz*                    = ASH(1,10);                (* horiz scroll text flows in textbox rather than extend to right *)
    dfDropShadow*                = ASH(1,12);                (* display text with a drop shadow *)
    dfAntiAlias*                    = ASH(1,13);                (* attempt to display text anti aliased*)
    dfKeyedText*                    = ASH(1,14);                (* key the text over background*)
    dfInverseHilite*                = ASH(1,15);                (* Use inverse hiliting rather than using hilite color*)

    searchTextDontGoToFoundTime*    = ASH(1,16);
    searchTextDontHiliteFoundText* = ASH(1,17);
    searchTextOneTrackOnly*        = ASH(1,18);
    searchTextEnabledTracksOnly*    = ASH(1,19);

(* progress messages *)
    movieProgressOpen*            = 0;
    movieProgressUpdatePercent*    = 1;
    movieProgressClose*            = 2;

(* progress operations *)
    progressOpFlatten*            = 1;
    progressOpInsertTrackSegment* = 2;
    progressOpInsertMovieSegment* = 3;
    progressOpPaste*                = 4;
    progressOpAddMovieSelection*    = 5;
    progressOpCopy*                = 6;
    progressOpCut*                = 7;
    progressOpLoadMovieIntoRam*    = 8;
    progressOpLoadTrackIntoRam*    = 9;
    progressOpLoadMediaIntoRam*    = 10;
    progressOpImportMovie*        = 11;
    progressOpExportMovie*        = 12;

    mediaQualityDraft*            = $0000;
    mediaQualityNormal*            = $0040;
    mediaQualityBetter*            = $0080;
    mediaQualityBest*            = $00C0;

TYPE
    MovieRgnCoverProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (theMovie: Movie; changedRgn: Quickdraw.RgnHandle; refcon: LONGINT): Types.OSErr;
    MovieProgressProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (theMovie: Movie; message: INTEGER; whatOperation: INTEGER; percentDone: Types.Fixed; refcon: LONGINT): Types.OSErr;
    MovieDrawingCompleteProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (theMovie: Movie; refCon: LONGINT): Types.OSErr;
    TrackTransferProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (t: Track; refCon: LONGINT): Types.OSErr;
    GetMovieProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (offset: LONGINT; size: LONGINT; dataPtr: (*ΔΔUNIVΔΔ*) Types.Ptr; refCon: (*ΔΔUNIVΔΔ*) Types.Ptr): Types.OSErr;
    MoviePreviewCallOutProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (refcon: LONGINT): BOOLEAN;
    MoviesErrorProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (theErr: Types.OSErr; refcon: LONGINT);
    TextMediaProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (theText: Types.Handle; theMovie: Movie; VAR displayFlag: INTEGER; refcon: LONGINT): Types.OSErr;
    MovieRgnCoverUPP* = Types.UniversalProcPtr;
    MovieProgressUPP* = Types.UniversalProcPtr;
    MovieDrawingCompleteUPP* = Types.UniversalProcPtr;
    TrackTransferUPP* = Types.UniversalProcPtr;
    GetMovieUPP* = Types.UniversalProcPtr;
    MoviePreviewCallOutUPP* = Types.UniversalProcPtr;
    MoviesErrorUPP* = Types.UniversalProcPtr;
    TextMediaUPP* = Types.UniversalProcPtr;

    MediaHandler* = Components.ComponentInstance;
    DataHandler* = Components.ComponentInstance;

    MediaHandlerComponent* = Components.Component;
    DataHandlerComponent* = Components.Component;

    HandlerError* = Components.ComponentResult;

    TimeValue* = LONGINT;

    TimeScale* = LONGINT;

    CompTimeValue* = Types.wide;


CONST
    loopTimeBase*                = 1;
    palindromeLoopTimeBase*        = 2;
    maintainTimeBaseZero*        = 4;


TYPE
    TimeBaseFlags* = LONGINT;

    TimeBaseRecord* = RECORD
        data*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
    END;

    TimeBase* = POINTER TO TimeBaseRecord;

    CallBackRecord* = RECORD
        data*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
    END;

    QTCallBack* = POINTER TO CallBackRecord;

    TimeRecord* = RECORD
        value*:                    CompTimeValue;                            (* units *)
        scale*:                    TimeScale;                                (* units per second *)
        base*:                    TimeBase;
    END;

(* CallBack equates *)

CONST
    triggerTimeFwd*                = $0001;                        (* when curTime exceeds triggerTime going forward *)
    triggerTimeBwd*                = $0002;                        (* when curTime exceeds triggerTime going backwards *)
    triggerTimeEither*            = $0003;                        (* when curTime exceeds triggerTime going either direction *)
    triggerRateLT*                = $0004;                        (* when rate changes to less than trigger value *)
    triggerRateGT*                = $0008;                        (* when rate changes to greater than trigger value *)
    triggerRateEqual*            = $0010;                        (* when rate changes to equal trigger value *)
    triggerRateLTE*                = triggerRateLT + triggerRateEqual;
    triggerRateGTE*                = triggerRateGT + triggerRateEqual;
    triggerRateNotEqual*            = triggerRateGT + triggerRateEqual + triggerRateLT;
    triggerRateChange*            = 0;
    triggerAtStart*                = $0001;
    triggerAtStop*                = $0002;


TYPE
    QTCallBackFlags* = INTEGER;


CONST
    timeBaseBeforeStartTime*        = 1;
    timeBaseAfterStopTime*        = 2;


TYPE
    TimeBaseStatus* = LONGINT;


CONST
    callBackAtTime*                = 1;
    callBackAtRate*                = 2;
    callBackAtTimeJump*            = 3;
    callBackAtExtremes*            = 4;
    callBackAtInterrupt*            = $8000;
    callBackAtDeferredTask*        = $4000;


TYPE
    QTCallBackType* = INTEGER;

    QTCallBackProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (cb: QTCallBack; refCon: LONGINT);
    QTCallBackUPP* = Types.UniversalProcPtr;


CONST
    qtcbNeedsRateChanges*        = 1;                            (* wants to know about rate changes *)
    qtcbNeedsTimeChanges*        = 2;                            (* wants to know about time changes *)
    qtcbNeedsStartStopChanges*    = 4;                            (* wants to know when TimeBase start/stop is changed*)


TYPE
    QTCallBackHeader* = RECORD
        callBackFlags*:            LONGINT;
        reserved1*:                LONGINT;
        qtPrivate*:                ARRAY 40 (*ΔΔ[0..39]ΔΔ*) OF Types.SInt8;
    END;

    QTSyncTaskProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (task: (*ΔΔUNIVΔΔ*) Types.Ptr);
    QTSyncTaskUPP* = Types.UniversalProcPtr;

    QTSyncTaskRecord* = RECORD
        qLink*:                    Types.Ptr;
        proc*:                    QTSyncTaskUPP;
    END;

    QTSyncTaskPtr* = POINTER TO QTSyncTaskRecord;


CONST
    keepInRam*                    = ASH(1,0);                    (* load and make non-purgable*)
    unkeepInRam*                    = ASH(1,1);                    (* mark as purgable*)
    flushFromRam*                = ASH(1,2);                    (* empty those handles*)
    loadForwardTrackEdits*        = ASH(1,3);                    (*    load track edits into ram for playing forward*)
    loadBackwardTrackEdits*        = ASH(1,4);                    (*    load track edits into ram for playing in reverse*)

    newMovieActive*                = ASH(1,0);
    newMovieDontResolveDataRefs*    = ASH(1,1);
    newMovieDontAskUnresolvedDataRefs* = ASH(1,2);
    newMovieDontAutoAlternates*    = ASH(1,3);

(* track usage bits *)
    trackUsageInMovie*            = ASH(1,1);
    trackUsageInPreview*            = ASH(1,2);
    trackUsageInPoster*            = ASH(1,3);

(* Add/GetMediaSample flags *)
    mediaSampleNotSync*            = ASH(1,0);                    (* sample is not a sync sample (eg. is frame differenced *)
    mediaSampleShadowSync*        = ASH(1,1);                    (* sample is a shadow sync *)

    pasteInParallel*                = 1;
    showUserSettingsDialog*        = 2;
    movieToFileOnlyExport*        = 4;

    nextTimeMediaSample*            = ASH(1,0);
    nextTimeMediaEdit*            = ASH(1,1);
    nextTimeTrackEdit*            = ASH(1,2);
    nextTimeSyncSample*            = ASH(1,3);
    nextTimeEdgeOK*                = ASH(1,14);
    nextTimeIgnoreActiveSegment*    = ASH(1,15);


TYPE
    nextTimeFlagsEnum* = INTEGER;


CONST
    createMovieFileDeleteCurFile* = ASH(1,31);
    createMovieFileDontCreateMovie* = ASH(1,30);
    createMovieFileDontOpenFile*    = ASH(1,29);


TYPE
    createMovieFileFlagsEnum* = LONGINT;


CONST
    flattenAddMovieToDataFork*    = ASH(1,0);
    flattenActiveTracksOnly*        = ASH(1,2);
    flattenDontInterleaveFlatten* = ASH(1,3);


TYPE
    movieFlattenFlagsEnum* = LONGINT;


CONST
    movieInDataForkResID*        = -1;                            (* magic res AIFF.ID *)

    mcTopLeftMovie*                = ASH(1,0);                    (* usually centered *)
    mcScaleMovieToFit*            = ASH(1,1);                    (* usually only scales down *)
    mcWithBadge*                    = ASH(1,2);                    (* give me a badge *)
    mcNotVisible*                = ASH(1,3);                    (* don't show controller *)
    mcWithFrame*                    = ASH(1,4);                    (* gimme a frame *)

    movieScrapDontZeroScrap*        = ASH(1,0);
    movieScrapOnlyPutMovie*        = ASH(1,1);

    dataRefSelfReference*        = ASH(1,0);
    dataRefWasNotResolved*        = ASH(1,1);


TYPE
    dataRefAttributesFlags* = LONGINT;


CONST
    hintsScrubMode*                = ASH(1,0);                    (* mask == && (if flags == scrub on, flags != scrub off) *)
    hintsLoop*                    = ASH(1,1);
    hintsDontPurge*                = ASH(1,2);
    hintsUseScreenBuffer*        = ASH(1,5);
    hintsAllowInterlace*            = ASH(1,6);
    hintsUseSoundInterp*            = ASH(1,7);
    hintsHighQuality*            = ASH(1,8);                    (* slooooow *)
    hintsPalindrome*                = ASH(1,9);
    hintsInactive*                = ASH(1,11);


TYPE
    playHintsEnum* = LONGINT;


CONST
    mediaHandlerFlagBaseClient*    = 1;


TYPE
    mediaHandlerFlagsEnum* = LONGINT;


CONST
    movieTrackMediaType*            = ASH(1,0);
    movieTrackCharacteristic*    = ASH(1,1);
    movieTrackEnabledOnly*        = ASH(1,2);


TYPE
    SampleReferenceRecord* = RECORD
        dataOffset*:                LONGINT;
        dataSize*:                LONGINT;
        durationPerSample*:        TimeValue;
        numberOfSamples*:        LONGINT;
        sampleFlags*:            INTEGER;
    END;

    SampleReferencePtr* = POINTER TO SampleReferenceRecord;

(*************************
* Initialization Routines
**************************)

PROCEDURE EnterMovies*(): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7001, $AAAA;
    (*$END*)
PROCEDURE ExitMovies*;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7002, $AAAA;
    (*$END*)
(*************************
* Error Routines
**************************)
PROCEDURE GetMoviesError*(): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7003, $AAAA;
    (*$END*)
PROCEDURE ClearMoviesStickyError*;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $DE, $AAAA;
    (*$END*)
PROCEDURE GetMoviesStickyError*(): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7004, $AAAA;
    (*$END*)
PROCEDURE SetMoviesErrorProc*(errProc: MoviesErrorUPP; refcon: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $EF, $AAAA;
    (*$END*)
(*************************
* Idle Routines
**************************)
PROCEDURE MoviesTask*(theMovie: Movie; maxMilliSecToUse: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7005, $AAAA;
    (*$END*)
PROCEDURE PrerollMovie*(theMovie: Movie; time: TimeValue; Rate: Types.Fixed): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7006, $AAAA;
    (*$END*)
PROCEDURE LoadMovieIntoRam*(theMovie: Movie; time: TimeValue; duration: TimeValue; flags: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7007, $AAAA;
    (*$END*)
PROCEDURE LoadTrackIntoRam*(theTrack: Track; time: TimeValue; duration: TimeValue; flags: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $16E, $AAAA;
    (*$END*)
PROCEDURE LoadMediaIntoRam*(theMedia: Media; time: TimeValue; duration: TimeValue; flags: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7008, $AAAA;
    (*$END*)
PROCEDURE SetMovieActive*(theMovie: Movie; active: BOOLEAN);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7009, $AAAA;
    (*$END*)
PROCEDURE GetMovieActive*(theMovie: Movie): BOOLEAN;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $700A, $AAAA;
    (*$END*)
(*************************
* calls for playing movies, previews, posters
**************************)
PROCEDURE StartMovie*(theMovie: Movie);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $700B, $AAAA;
    (*$END*)
PROCEDURE StopMovie*(theMovie: Movie);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $700C, $AAAA;
    (*$END*)
PROCEDURE GoToBeginningOfMovie*(theMovie: Movie);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $700D, $AAAA;
    (*$END*)
PROCEDURE GoToEndOfMovie*(theMovie: Movie);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $700E, $AAAA;
    (*$END*)
PROCEDURE IsMovieDone*(theMovie: Movie): BOOLEAN;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $DD, $AAAA;
    (*$END*)
PROCEDURE GetMoviePreviewMode*(theMovie: Movie): BOOLEAN;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $700F, $AAAA;
    (*$END*)
PROCEDURE SetMoviePreviewMode*(theMovie: Movie; usePreview: BOOLEAN);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7010, $AAAA;
    (*$END*)
PROCEDURE ShowMoviePoster*(theMovie: Movie);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7011, $AAAA;
    (*$END*)
PROCEDURE PlayMoviePreview*(theMovie: Movie; callOutProc: MoviePreviewCallOutUPP; refcon: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $F2, $AAAA;
    (*$END*)
(*************************
* calls for controlling movies & tracks which are playing
**************************)
PROCEDURE GetMovieTimeBase*(theMovie: Movie): TimeBase;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7012, $AAAA;
    (*$END*)
PROCEDURE SetMovieMasterTimeBase*(theMovie: Movie; tb: TimeBase; (*CONST*)VAR slaveZero: TimeRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $167, $AAAA;
    (*$END*)
PROCEDURE SetMovieMasterClock*(theMovie: Movie; clockMeister: Components.Component; (*CONST*)VAR slaveZero: TimeRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $168, $AAAA;
    (*$END*)
PROCEDURE GetMovieGWorld*(theMovie: Movie; VAR port: Quickdraw.CGrafPtr; VAR gdh: Quickdraw.GDHandle);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7015, $AAAA;
    (*$END*)
PROCEDURE SetMovieGWorld*(theMovie: Movie; port: Quickdraw.CGrafPtr; gdh: Quickdraw.GDHandle);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7016, $AAAA;
    (*$END*)

CONST
    movieDrawingCallWhenChanged*    = 0;
    movieDrawingCallAlways*        = 1;


PROCEDURE SetMovieDrawingCompleteProc*(theMovie: Movie; flags: LONGINT; proc: MovieDrawingCompleteUPP; refCon: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1DE, $AAAA;
    (*$END*)
PROCEDURE GetNextTrackForCompositing*(theMovie: Movie; theTrack: Track): Track;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1FA, $AAAA;
    (*$END*)
PROCEDURE GetPrevTrackForCompositing*(theMovie: Movie; theTrack: Track): Track;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1FB, $AAAA;
    (*$END*)
PROCEDURE SetTrackGWorld*(theTrack: Track; port: Quickdraw.CGrafPtr; gdh: Quickdraw.GDHandle; proc: TrackTransferUPP; refCon: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $9D, $AAAA;
    (*$END*)
PROCEDURE GetMoviePict*(theMovie: Movie; time: TimeValue): Quickdraw.PicHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $701D, $AAAA;
    (*$END*)
PROCEDURE GetTrackPict*(theTrack: Track; time: TimeValue): Quickdraw.PicHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $701E, $AAAA;
    (*$END*)
PROCEDURE GetMoviePosterPict*(theMovie: Movie): Quickdraw.PicHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $F7, $AAAA;
    (*$END*)
(* called between Begin & EndUpdate *)
PROCEDURE UpdateMovie*(theMovie: Movie): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $701F, $AAAA;
    (*$END*)
(**** spatial movie routines ****)
PROCEDURE GetMovieBox*(theMovie: Movie; VAR boxRect: Types.Rect);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $F9, $AAAA;
    (*$END*)
PROCEDURE SetMovieBox*(theMovie: Movie; (*CONST*)VAR boxRect: Types.Rect);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $FA, $AAAA;
    (*$END*)
(** movie display clip *)
PROCEDURE GetMovieDisplayClipRgn*(theMovie: Movie): Quickdraw.RgnHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $FC, $AAAA;
    (*$END*)
PROCEDURE SetMovieDisplayClipRgn*(theMovie: Movie; theClip: Quickdraw.RgnHandle);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $FD, $AAAA;
    (*$END*)
(** movie src clip *)
PROCEDURE GetMovieClipRgn*(theMovie: Movie): Quickdraw.RgnHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $100, $AAAA;
    (*$END*)
PROCEDURE SetMovieClipRgn*(theMovie: Movie; theClip: Quickdraw.RgnHandle);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $101, $AAAA;
    (*$END*)
(** track src clip *)
PROCEDURE GetTrackClipRgn*(theTrack: Track): Quickdraw.RgnHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $102, $AAAA;
    (*$END*)
PROCEDURE SetTrackClipRgn*(theTrack: Track; theClip: Quickdraw.RgnHandle);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $103, $AAAA;
    (*$END*)
(** bounds in display space (not clipped by display clip) *)
PROCEDURE GetMovieDisplayBoundsRgn*(theMovie: Movie): Quickdraw.RgnHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $FB, $AAAA;
    (*$END*)
PROCEDURE GetTrackDisplayBoundsRgn*(theTrack: Track): Quickdraw.RgnHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $112, $AAAA;
    (*$END*)
(** bounds in movie space *)
PROCEDURE GetMovieBoundsRgn*(theMovie: Movie): Quickdraw.RgnHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $FE, $AAAA;
    (*$END*)
PROCEDURE GetTrackMovieBoundsRgn*(theTrack: Track): Quickdraw.RgnHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $FF, $AAAA;
    (*$END*)
(** bounds in track space *)
PROCEDURE GetTrackBoundsRgn*(theTrack: Track): Quickdraw.RgnHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $111, $AAAA;
    (*$END*)
(** mattes - always in track space *)
PROCEDURE GetTrackMatte*(theTrack: Track): Quickdraw.PixMapHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $115, $AAAA;
    (*$END*)
PROCEDURE SetTrackMatte*(theTrack: Track; theMatte: Quickdraw.PixMapHandle);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $116, $AAAA;
    (*$END*)
PROCEDURE DisposeMatte*(theMatte: Quickdraw.PixMapHandle);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $14A, $AAAA;
    (*$END*)
(*************************
* calls for getting/saving movies
**************************)
PROCEDURE NewMovie*(flags: LONGINT): Movie;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $187, $AAAA;
    (*$END*)
PROCEDURE PutMovieIntoHandle*(theMovie: Movie; publicMovie: Types.Handle): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7022, $AAAA;
    (*$END*)
PROCEDURE PutMovieIntoDataFork*(theMovie: Movie; fRefNum: INTEGER; offset: LONGINT; maxSize: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1B4, $AAAA;
    (*$END*)
PROCEDURE DisposeMovie*(theMovie: Movie);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7023, $AAAA;
    (*$END*)
(*************************
* Movie State Routines
**************************)
PROCEDURE GetMovieCreationTime*(theMovie: Movie): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7026, $AAAA;
    (*$END*)
PROCEDURE GetMovieModificationTime*(theMovie: Movie): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7027, $AAAA;
    (*$END*)
PROCEDURE GetMovieTimeScale*(theMovie: Movie): TimeScale;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7029, $AAAA;
    (*$END*)
PROCEDURE SetMovieTimeScale*(theMovie: Movie; timeScale: TimeScale);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $702A, $AAAA;
    (*$END*)
PROCEDURE GetMovieDuration*(theMovie: Movie): TimeValue;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $702B, $AAAA;
    (*$END*)
PROCEDURE GetMovieRate*(theMovie: Movie): Types.Fixed;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $702C, $AAAA;
    (*$END*)
PROCEDURE SetMovieRate*(theMovie: Movie; rate: Types.Fixed);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $702D, $AAAA;
    (*$END*)
PROCEDURE GetMoviePreferredRate*(theMovie: Movie): Types.Fixed;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $F3, $AAAA;
    (*$END*)
PROCEDURE SetMoviePreferredRate*(theMovie: Movie; rate: Types.Fixed);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $F4, $AAAA;
    (*$END*)
PROCEDURE GetMoviePreferredVolume*(theMovie: Movie): INTEGER;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $F5, $AAAA;
    (*$END*)
PROCEDURE SetMoviePreferredVolume*(theMovie: Movie; volume: INTEGER);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $F6, $AAAA;
    (*$END*)
PROCEDURE GetMovieVolume*(theMovie: Movie): INTEGER;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $702E, $AAAA;
    (*$END*)
PROCEDURE SetMovieVolume*(theMovie: Movie; volume: INTEGER);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $702F, $AAAA;
    (*$END*)
PROCEDURE GetMovieMatrix*(theMovie: Movie; VAR matrix: ImageCompression.MatrixRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7031, $AAAA;
    (*$END*)
PROCEDURE SetMovieMatrix*(theMovie: Movie; (*CONST*)VAR matrix: ImageCompression.MatrixRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7032, $AAAA;
    (*$END*)
PROCEDURE GetMoviePreviewTime*(theMovie: Movie; VAR previewTime: TimeValue; VAR previewDuration: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7033, $AAAA;
    (*$END*)
PROCEDURE SetMoviePreviewTime*(theMovie: Movie; previewTime: TimeValue; previewDuration: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7034, $AAAA;
    (*$END*)
PROCEDURE GetMoviePosterTime*(theMovie: Movie): TimeValue;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7035, $AAAA;
    (*$END*)
PROCEDURE SetMoviePosterTime*(theMovie: Movie; posterTime: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7036, $AAAA;
    (*$END*)
PROCEDURE GetMovieSelection*(theMovie: Movie; VAR selectionTime: TimeValue; VAR selectionDuration: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7037, $AAAA;
    (*$END*)
PROCEDURE SetMovieSelection*(theMovie: Movie; selectionTime: TimeValue; selectionDuration: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7038, $AAAA;
    (*$END*)
PROCEDURE SetMovieActiveSegment*(theMovie: Movie; startTime: TimeValue; duration: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $15C, $AAAA;
    (*$END*)
PROCEDURE GetMovieActiveSegment*(theMovie: Movie; VAR startTime: TimeValue; VAR duration: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $15D, $AAAA;
    (*$END*)
PROCEDURE GetMovieTime*(theMovie: Movie; VAR currentTime: TimeRecord): TimeValue;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7039, $AAAA;
    (*$END*)
PROCEDURE SetMovieTime*(theMovie: Movie; (*CONST*)VAR newtime: TimeRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $703C, $AAAA;
    (*$END*)
PROCEDURE SetMovieTimeValue*(theMovie: Movie; newtime: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $703D, $AAAA;
    (*$END*)
PROCEDURE GetMovieUserData*(theMovie: Movie): UserData;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $703E, $AAAA;
    (*$END*)
(*************************
* Track/Media finding routines
**************************)
PROCEDURE GetMovieTrackCount*(theMovie: Movie): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $703F, $AAAA;
    (*$END*)
PROCEDURE GetMovieTrack*(theMovie: Movie; trackID: LONGINT): Track;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7040, $AAAA;
    (*$END*)
PROCEDURE GetMovieIndTrack*(theMovie: Movie; index: LONGINT): Track;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $117, $AAAA;
    (*$END*)
PROCEDURE GetMovieIndTrackType*(theMovie: Movie; index: LONGINT; trackType: Types.OSType; flags: LONGINT): Track;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $208, $AAAA;
    (*$END*)
PROCEDURE GetTrackID*(theTrack: Track): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $127, $AAAA;
    (*$END*)
PROCEDURE GetTrackMovie*(theTrack: Track): Movie;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $D0, $AAAA;
    (*$END*)
(*************************
* Track creation routines
**************************)
PROCEDURE NewMovieTrack*(theMovie: Movie; width: Types.Fixed; height: Types.Fixed; trackVolume: INTEGER): Track;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $188, $AAAA;
    (*$END*)
PROCEDURE DisposeMovieTrack*(theTrack: Track);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7042, $AAAA;
    (*$END*)
(*************************
* Track State routines
**************************)
PROCEDURE GetTrackCreationTime*(theTrack: Track): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7043, $AAAA;
    (*$END*)
PROCEDURE GetTrackModificationTime*(theTrack: Track): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7044, $AAAA;
    (*$END*)
PROCEDURE GetTrackEnabled*(theTrack: Track): BOOLEAN;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7045, $AAAA;
    (*$END*)
PROCEDURE SetTrackEnabled*(theTrack: Track; isEnabled: BOOLEAN);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7046, $AAAA;
    (*$END*)
PROCEDURE GetTrackUsage*(theTrack: Track): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7047, $AAAA;
    (*$END*)
PROCEDURE SetTrackUsage*(theTrack: Track; usage: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7048, $AAAA;
    (*$END*)
PROCEDURE GetTrackDuration*(theTrack: Track): TimeValue;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $704B, $AAAA;
    (*$END*)
PROCEDURE GetTrackOffset*(theTrack: Track): TimeValue;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $704C, $AAAA;
    (*$END*)
PROCEDURE SetTrackOffset*(theTrack: Track; movieOffsetTime: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $704D, $AAAA;
    (*$END*)
PROCEDURE GetTrackLayer*(theTrack: Track): INTEGER;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7050, $AAAA;
    (*$END*)
PROCEDURE SetTrackLayer*(theTrack: Track; layer: INTEGER);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7051, $AAAA;
    (*$END*)
PROCEDURE GetTrackAlternate*(theTrack: Track): Track;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7052, $AAAA;
    (*$END*)
PROCEDURE SetTrackAlternate*(theTrack: Track; alternateT: Track);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7053, $AAAA;
    (*$END*)
PROCEDURE SetAutoTrackAlternatesEnabled*(theMovie: Movie; enable: BOOLEAN);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $15E, $AAAA;
    (*$END*)
PROCEDURE SelectMovieAlternates*(theMovie: Movie);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $15F, $AAAA;
    (*$END*)
PROCEDURE GetTrackVolume*(theTrack: Track): INTEGER;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7054, $AAAA;
    (*$END*)
PROCEDURE SetTrackVolume*(theTrack: Track; volume: INTEGER);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7055, $AAAA;
    (*$END*)
PROCEDURE GetTrackMatrix*(theTrack: Track; VAR matrix: ImageCompression.MatrixRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7056, $AAAA;
    (*$END*)
PROCEDURE SetTrackMatrix*(theTrack: Track; (*CONST*)VAR matrix: ImageCompression.MatrixRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7057, $AAAA;
    (*$END*)
PROCEDURE GetTrackDimensions*(theTrack: Track; VAR width: Types.Fixed; VAR height: Types.Fixed);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $705D, $AAAA;
    (*$END*)
PROCEDURE SetTrackDimensions*(theTrack: Track; width: Types.Fixed; height: Types.Fixed);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $705E, $AAAA;
    (*$END*)
PROCEDURE GetTrackUserData*(theTrack: Track): UserData;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $705F, $AAAA;
    (*$END*)
(*************************
* get Media routines
**************************)
PROCEDURE NewTrackMedia*(theTrack: Track; mediaType: Types.OSType; timeScale: TimeScale; dataRef: Types.Handle; dataRefType: Types.OSType): Media;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $18E, $AAAA;
    (*$END*)
PROCEDURE DisposeTrackMedia*(theMedia: Media);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7061, $AAAA;
    (*$END*)
PROCEDURE GetTrackMedia*(theTrack: Track): Media;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7062, $AAAA;
    (*$END*)
PROCEDURE GetMediaTrack*(theMedia: Media): Track;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $C5, $AAAA;
    (*$END*)
(*************************
* Media State routines
**************************)
PROCEDURE GetMediaCreationTime*(theMedia: Media): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7066, $AAAA;
    (*$END*)
PROCEDURE GetMediaModificationTime*(theMedia: Media): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7067, $AAAA;
    (*$END*)
PROCEDURE GetMediaTimeScale*(theMedia: Media): TimeScale;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7068, $AAAA;
    (*$END*)
PROCEDURE SetMediaTimeScale*(theMedia: Media; timeScale: TimeScale);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7069, $AAAA;
    (*$END*)
PROCEDURE GetMediaDuration*(theMedia: Media): TimeValue;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $706A, $AAAA;
    (*$END*)
PROCEDURE GetMediaLanguage*(theMedia: Media): INTEGER;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $706B, $AAAA;
    (*$END*)
PROCEDURE SetMediaLanguage*(theMedia: Media; language: INTEGER);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $706C, $AAAA;
    (*$END*)
PROCEDURE GetMediaQuality*(theMedia: Media): INTEGER;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $706D, $AAAA;
    (*$END*)
PROCEDURE SetMediaQuality*(theMedia: Media; quality: INTEGER);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $706E, $AAAA;
    (*$END*)
PROCEDURE GetMediaHandlerDescription*(theMedia: Media; VAR mediaType: Types.OSType; VAR creatorName: Types.Str255; VAR creatorManufacturer: Types.OSType);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $706F, $AAAA;
    (*$END*)
PROCEDURE GetMediaUserData*(theMedia: Media): UserData;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7070, $AAAA;
    (*$END*)
(*************************
* Media Handler routines
**************************)
PROCEDURE GetMediaHandler*(theMedia: Media): MediaHandler;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7071, $AAAA;
    (*$END*)
PROCEDURE SetMediaHandler*(theMedia: Media; mH: MediaHandlerComponent): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $190, $AAAA;
    (*$END*)
(*************************
* Media's Data routines
**************************)
PROCEDURE BeginMediaEdits*(theMedia: Media): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7072, $AAAA;
    (*$END*)
PROCEDURE EndMediaEdits*(theMedia: Media): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7073, $AAAA;
    (*$END*)
PROCEDURE SetMediaDefaultDataRefIndex*(theMedia: Media; index: INTEGER): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1E0, $AAAA;
    (*$END*)
PROCEDURE GetMediaDataHandlerDescription*(theMedia: Media; index: INTEGER; VAR dhType: Types.OSType; VAR creatorName: Types.Str255; VAR creatorManufacturer: Types.OSType);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $19E, $AAAA;
    (*$END*)
PROCEDURE GetMediaDataHandler*(theMedia: Media; index: INTEGER): DataHandler;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $19F, $AAAA;
    (*$END*)
PROCEDURE SetMediaDataHandler*(theMedia: Media; index: INTEGER; dataHandler: DataHandlerComponent): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1A0, $AAAA;
    (*$END*)
PROCEDURE GetDataHandler*(dataRef: Types.Handle; dataHandlerSubType: Types.OSType; flags: LONGINT): Components.Component;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1ED, $AAAA;
    (*$END*)
(*************************
* Media Sample Table Routines
**************************)
PROCEDURE GetMediaSampleDescriptionCount*(theMedia: Media): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7077, $AAAA;
    (*$END*)
PROCEDURE GetMediaSampleDescription*(theMedia: Media; index: LONGINT; descH: SampleDescriptionHandle);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7078, $AAAA;
    (*$END*)
PROCEDURE SetMediaSampleDescription*(theMedia: Media; index: LONGINT; descH: SampleDescriptionHandle): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1D0, $AAAA;
    (*$END*)
PROCEDURE GetMediaSampleCount*(theMedia: Media): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7079, $AAAA;
    (*$END*)
PROCEDURE SampleNumToMediaTime*(theMedia: Media; logicalSampleNum: LONGINT; VAR sampleTime: TimeValue; VAR sampleDuration: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $707A, $AAAA;
    (*$END*)
PROCEDURE MediaTimeToSampleNum*(theMedia: Media; time: TimeValue; VAR sampleNum: LONGINT; VAR sampleTime: TimeValue; VAR sampleDuration: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $707B, $AAAA;
    (*$END*)
PROCEDURE AddMediaSample*(theMedia: Media; dataIn: Types.Handle; inOffset: LONGINT; size: LONGINT; durationPerSample: TimeValue; sampleDescriptionH: SampleDescriptionHandle; numberOfSamples: LONGINT; sampleFlags: INTEGER; VAR sampleTime: TimeValue): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $707C, $AAAA;
    (*$END*)
PROCEDURE AddMediaSampleReference*(theMedia: Media; dataOffset: LONGINT; size: LONGINT; durationPerSample: TimeValue; sampleDescriptionH: SampleDescriptionHandle; numberOfSamples: LONGINT; sampleFlags: INTEGER; VAR sampleTime: TimeValue): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $707D, $AAAA;
    (*$END*)
PROCEDURE AddMediaSampleReferences*(theMedia: Media; sampleDescriptionH: SampleDescriptionHandle; numberOfSamples: LONGINT; sampleRefs: SampleReferencePtr; VAR sampleTime: TimeValue): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1F7, $AAAA;
    (*$END*)
PROCEDURE GetMediaSample*(theMedia: Media; dataOut: Types.Handle; maxSizeToGrow: LONGINT; VAR size: LONGINT; time: TimeValue; VAR sampleTime: TimeValue; VAR durationPerSample: TimeValue; sampleDescriptionH: SampleDescriptionHandle; VAR sampleDescriptionIndex: LONGINT; maxNumberOfSamples: LONGINT; VAR numberOfSamples: LONGINT; VAR sampleFlags: INTEGER): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $707E, $AAAA;
    (*$END*)
PROCEDURE GetMediaSampleReference*(theMedia: Media; VAR dataOffset: LONGINT; VAR size: LONGINT; time: TimeValue; VAR sampleTime: TimeValue; VAR durationPerSample: TimeValue; sampleDescriptionH: SampleDescriptionHandle; VAR sampleDescriptionIndex: LONGINT; maxNumberOfSamples: LONGINT; VAR numberOfSamples: LONGINT; VAR sampleFlags: INTEGER): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $707F, $AAAA;
    (*$END*)
PROCEDURE SetMediaPreferredChunkSize*(theMedia: Media; maxChunkSize: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1F8, $AAAA;
    (*$END*)
PROCEDURE GetMediaPreferredChunkSize*(theMedia: Media; VAR maxChunkSize: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1F9, $AAAA;
    (*$END*)
PROCEDURE SetMediaShadowSync*(theMedia: Media; frameDiffSampleNum: LONGINT; syncSampleNum: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $121, $AAAA;
    (*$END*)
PROCEDURE GetMediaShadowSync*(theMedia: Media; frameDiffSampleNum: LONGINT; VAR syncSampleNum: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $122, $AAAA;
    (*$END*)
(*************************
* Editing Routines
**************************)
PROCEDURE InsertMediaIntoTrack*(theTrack: Track; trackStart: TimeValue; mediaTime: TimeValue; mediaDuration: TimeValue; mediaRate: Types.Fixed): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $183, $AAAA;
    (*$END*)
PROCEDURE InsertTrackSegment*(srcTrack: Track; dstTrack: Track; srcIn: TimeValue; srcDuration: TimeValue; dstIn: TimeValue): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $85, $AAAA;
    (*$END*)
PROCEDURE InsertMovieSegment*(srcMovie: Movie; dstMovie: Movie; srcIn: TimeValue; srcDuration: TimeValue; dstIn: TimeValue): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $86, $AAAA;
    (*$END*)
PROCEDURE InsertEmptyTrackSegment*(dstTrack: Track; dstIn: TimeValue; dstDuration: TimeValue): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $87, $AAAA;
    (*$END*)
PROCEDURE InsertEmptyMovieSegment*(dstMovie: Movie; dstIn: TimeValue; dstDuration: TimeValue): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $88, $AAAA;
    (*$END*)
PROCEDURE DeleteTrackSegment*(theTrack: Track; startTime: TimeValue; duration: TimeValue): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $89, $AAAA;
    (*$END*)
PROCEDURE DeleteMovieSegment*(theMovie: Movie; startTime: TimeValue; duration: TimeValue): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $8A, $AAAA;
    (*$END*)
PROCEDURE ScaleTrackSegment*(theTrack: Track; startTime: TimeValue; oldDuration: TimeValue; newDuration: TimeValue): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $8B, $AAAA;
    (*$END*)
PROCEDURE ScaleMovieSegment*(theMovie: Movie; startTime: TimeValue; oldDuration: TimeValue; newDuration: TimeValue): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $8C, $AAAA;
    (*$END*)
(*************************
* Hi-level Editing Routines
**************************)
PROCEDURE CutMovieSelection*(theMovie: Movie): Movie;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $8D, $AAAA;
    (*$END*)
PROCEDURE CopyMovieSelection*(theMovie: Movie): Movie;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $8E, $AAAA;
    (*$END*)
PROCEDURE PasteMovieSelection*(theMovie: Movie; src: Movie);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $8F, $AAAA;
    (*$END*)
PROCEDURE AddMovieSelection*(theMovie: Movie; src: Movie);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $152, $AAAA;
    (*$END*)
PROCEDURE ClearMovieSelection*(theMovie: Movie);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $E1, $AAAA;
    (*$END*)
PROCEDURE PasteHandleIntoMovie*(h: Types.Handle; handleType: Types.OSType; theMovie: Movie; flags: LONGINT; userComp: Components.ComponentInstance): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $CB, $AAAA;
    (*$END*)
PROCEDURE PutMovieIntoTypedHandle*(theMovie: Movie; targetTrack: Track; handleType: Types.OSType; publicMovie: Types.Handle; start: TimeValue; dur: TimeValue; flags: LONGINT; userComp: Components.ComponentInstance): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1CD, $AAAA;
    (*$END*)
PROCEDURE IsScrapMovie*(targetTrack: Track): Components.Component;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $CC, $AAAA;
    (*$END*)
(*************************
* Middle-level Editing Routines
**************************)
PROCEDURE CopyTrackSettings*(srcTrack: Track; dstTrack: Track): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $153, $AAAA;
    (*$END*)
PROCEDURE CopyMovieSettings*(srcMovie: Movie; dstMovie: Movie): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $154, $AAAA;
    (*$END*)
PROCEDURE AddEmptyTrackToMovie*(srcTrack: Track; dstMovie: Movie; dataRef: Types.Handle; dataRefType: Types.OSType; VAR dstTrack: Track): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $7074, $AAAA;
    (*$END*)
(*************************
* movie & track edit state routines
**************************)
PROCEDURE NewMovieEditState*(theMovie: Movie): MovieEditState;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $104, $AAAA;
    (*$END*)
PROCEDURE UseMovieEditState*(theMovie: Movie; toState: MovieEditState): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $105, $AAAA;
    (*$END*)
PROCEDURE DisposeMovieEditState*(state: MovieEditState): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $106, $AAAA;
    (*$END*)
PROCEDURE NewTrackEditState*(theTrack: Track): TrackEditState;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $107, $AAAA;
    (*$END*)
PROCEDURE UseTrackEditState*(theTrack: Track; state: TrackEditState): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $108, $AAAA;
    (*$END*)
PROCEDURE DisposeTrackEditState*(state: TrackEditState): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $109, $AAAA;
    (*$END*)
(*************************
* track reference routines
**************************)
PROCEDURE AddTrackReference*(theTrack: Track; refTrack: Track; refType: Types.OSType; VAR addedIndex: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1F0, $AAAA;
    (*$END*)
PROCEDURE DeleteTrackReference*(theTrack: Track; refType: Types.OSType; index: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1F1, $AAAA;
    (*$END*)
PROCEDURE SetTrackReference*(theTrack: Track; refTrack: Track; refType: Types.OSType; index: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1F2, $AAAA;
    (*$END*)
PROCEDURE GetTrackReference*(theTrack: Track; refType: Types.OSType; index: LONGINT): Track;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1F3, $AAAA;
    (*$END*)
PROCEDURE GetNextTrackReferenceType*(theTrack: Track; refType: Types.OSType): Types.OSType;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1F4, $AAAA;
    (*$END*)
PROCEDURE GetTrackReferenceCount*(theTrack: Track; refType: Types.OSType): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1F5, $AAAA;
    (*$END*)
(*************************
* high level file conversion routines
**************************)
PROCEDURE ConvertFileToMovieFile*((*CONST*)VAR inputFile: Files.FSSpec; (*CONST*)VAR outputFile: Files.FSSpec; creator: Types.OSType; scriptTag: Types.ScriptCode; VAR resID: INTEGER; flags: LONGINT; userComp: Components.ComponentInstance; proc: MovieProgressUPP; refCon: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1CB, $AAAA;
    (*$END*)
PROCEDURE ConvertMovieToFile*(theMovie: Movie; onlyTrack: Track; VAR outputFile: Files.FSSpec; fileType: Types.OSType; creator: Types.OSType; scriptTag: Types.ScriptCode; VAR resID: INTEGER; flags: LONGINT; userComp: Components.ComponentInstance): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1CC, $AAAA;
    (*$END*)
(*************************
* Movie Timebase Conversion Routines
**************************)
PROCEDURE TrackTimeToMediaTime*(value: TimeValue; theTrack: Track): TimeValue;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $96, $AAAA;
    (*$END*)
PROCEDURE GetTrackEditRate*(theTrack: Track; atTime: TimeValue): Types.Fixed;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $123, $AAAA;
    (*$END*)
(*************************
* Miscellaneous Routines
**************************)
PROCEDURE GetMovieDataSize*(theMovie: Movie; startTime: TimeValue; duration: TimeValue): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $98, $AAAA;
    (*$END*)
PROCEDURE GetTrackDataSize*(theTrack: Track; startTime: TimeValue; duration: TimeValue): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $149, $AAAA;
    (*$END*)
PROCEDURE GetMediaDataSize*(theMedia: Media; startTime: TimeValue; duration: TimeValue): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $99, $AAAA;
    (*$END*)
PROCEDURE PtInMovie*(theMovie: Movie; pt: Types.Point): BOOLEAN;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $9A, $AAAA;
    (*$END*)
PROCEDURE PtInTrack*(theTrack: Track; pt: Types.Point): BOOLEAN;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $9B, $AAAA;
    (*$END*)
(*************************
* Group Selection Routines
**************************)
PROCEDURE SetMovieLanguage*(theMovie: Movie; language: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $9C, $AAAA;
    (*$END*)
(*************************
* User Data
**************************)
PROCEDURE GetUserData*(theUserData: UserData; data: Types.Handle; udType: Types.OSType; index: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $9E, $AAAA;
    (*$END*)
PROCEDURE AddUserData*(theUserData: UserData; data: Types.Handle; udType: Types.OSType): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $9F, $AAAA;
    (*$END*)
PROCEDURE RemoveUserData*(theUserData: UserData; udType: Types.OSType; index: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $A0, $AAAA;
    (*$END*)
PROCEDURE CountUserDataType*(theUserData: UserData; udType: Types.OSType): INTEGER;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $14B, $AAAA;
    (*$END*)
PROCEDURE GetNextUserDataType*(theUserData: UserData; udType: Types.OSType): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1A5, $AAAA;
    (*$END*)
PROCEDURE GetUserDataItem*(theUserData: UserData; data: (*ΔΔUNIVΔΔ*) Types.Ptr; size: LONGINT; udType: Types.OSType; index: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $126, $AAAA;
    (*$END*)
PROCEDURE SetUserDataItem*(theUserData: UserData; data: (*ΔΔUNIVΔΔ*) Types.Ptr; size: LONGINT; udType: Types.OSType; index: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $12E, $AAAA;
    (*$END*)
PROCEDURE AddUserDataText*(theUserData: UserData; data: Types.Handle; udType: Types.OSType; index: LONGINT; itlRegionTag: INTEGER): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $14C, $AAAA;
    (*$END*)
PROCEDURE GetUserDataText*(theUserData: UserData; data: Types.Handle; udType: Types.OSType; index: LONGINT; itlRegionTag: INTEGER): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $14D, $AAAA;
    (*$END*)
PROCEDURE RemoveUserDataText*(theUserData: UserData; udType: Types.OSType; index: LONGINT; itlRegionTag: INTEGER): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $14E, $AAAA;
    (*$END*)
PROCEDURE NewUserData*(VAR theUserData: UserData): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $12F, $AAAA;
    (*$END*)
PROCEDURE DisposeUserData*(theUserData: UserData): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $130, $AAAA;
    (*$END*)
PROCEDURE NewUserDataFromHandle*(h: Types.Handle; VAR theUserData: UserData): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $131, $AAAA;
    (*$END*)
PROCEDURE PutUserDataIntoHandle*(theUserData: UserData; h: Types.Handle): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $132, $AAAA;
    (*$END*)
PROCEDURE GetMediaNextInterestingTime*(theMedia: Media; interestingTimeFlags: INTEGER; time: TimeValue; rate: Types.Fixed; VAR interestingTime: TimeValue; VAR interestingDuration: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $16D, $AAAA;
    (*$END*)
PROCEDURE GetTrackNextInterestingTime*(theTrack: Track; interestingTimeFlags: INTEGER; time: TimeValue; rate: Types.Fixed; VAR interestingTime: TimeValue; VAR interestingDuration: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $E2, $AAAA;
    (*$END*)
PROCEDURE GetMovieNextInterestingTime*(theMovie: Movie; interestingTimeFlags: INTEGER; numMediaTypes: INTEGER; (*CONST*)VAR whichMediaTypes: Types.OSType; time: TimeValue; rate: Types.Fixed; VAR interestingTime: TimeValue; VAR interestingDuration: TimeValue);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $10E, $AAAA;
    (*$END*)
PROCEDURE CreateMovieFile*((*CONST*)VAR fileSpec: Files.FSSpec; creator: Types.OSType; scriptTag: Types.ScriptCode; createMovieFileFlags: LONGINT; VAR resRefNum: INTEGER; VAR newmovie: Movie): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $191, $AAAA;
    (*$END*)
PROCEDURE OpenMovieFile*((*CONST*)VAR fileSpec: Files.FSSpec; VAR resRefNum: INTEGER; permission: Types.ByteParameter): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $192, $AAAA;
    (*$END*)
PROCEDURE CloseMovieFile*(resRefNum: INTEGER): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $D5, $AAAA;
    (*$END*)
PROCEDURE DeleteMovieFile*((*CONST*)VAR fileSpec: Files.FSSpec): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $175, $AAAA;
    (*$END*)
PROCEDURE NewMovieFromFile*(VAR theMovie: Movie; resRefNum: INTEGER; VAR resId: INTEGER; resName: Types.StringPtr; newMovieFlags: INTEGER; VAR dataRefWasChanged: BOOLEAN): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $F0, $AAAA;
    (*$END*)
PROCEDURE NewMovieFromHandle*(VAR theMovie: Movie; h: Types.Handle; newMovieFlags: INTEGER; VAR dataRefWasChanged: BOOLEAN): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $F1, $AAAA;
    (*$END*)
PROCEDURE NewMovieFromDataFork*(VAR theMovie: Movie; fRefNum: INTEGER; fileOffset: LONGINT; newMovieFlags: INTEGER; VAR dataRefWasChanged: BOOLEAN): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1B3, $AAAA;
    (*$END*)
PROCEDURE NewMovieFromUserProc*(VAR m: Movie; flags: INTEGER; VAR dataRefWasChanged: BOOLEAN; getProc: GetMovieUPP; refCon: (*ΔΔUNIVΔΔ*) Types.Ptr; defaultDataRef: Types.Handle; dataRefType: Types.OSType): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1EC, $AAAA;
    (*$END*)
PROCEDURE AddMovieResource*(theMovie: Movie; resRefNum: INTEGER; VAR resId: INTEGER; resName: Types.ConstStr255Param): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $D7, $AAAA;
    (*$END*)
PROCEDURE UpdateMovieResource*(theMovie: Movie; resRefNum: INTEGER; resId: INTEGER; resName: Types.ConstStr255Param): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $D8, $AAAA;
    (*$END*)
PROCEDURE RemoveMovieResource*(resRefNum: INTEGER; resId: INTEGER): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $176, $AAAA;
    (*$END*)
PROCEDURE HasMovieChanged*(theMovie: Movie): BOOLEAN;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $D9, $AAAA;
    (*$END*)
PROCEDURE ClearMovieChanged*(theMovie: Movie);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $113, $AAAA;
    (*$END*)
PROCEDURE SetMovieDefaultDataRef*(theMovie: Movie; dataRef: Types.Handle; dataRefType: Types.OSType): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1C1, $AAAA;
    (*$END*)
PROCEDURE GetMovieDefaultDataRef*(theMovie: Movie; VAR dataRef: Types.Handle; VAR dataRefType: Types.OSType): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1D2, $AAAA;
    (*$END*)
PROCEDURE SetMovieColorTable*(theMovie: Movie; ctab: Quickdraw.CTabHandle): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $205, $AAAA;
    (*$END*)
PROCEDURE GetMovieColorTable*(theMovie: Movie; VAR ctab: Quickdraw.CTabHandle): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $206, $AAAA;
    (*$END*)
PROCEDURE FlattenMovie*(theMovie: Movie; movieFlattenFlags: LONGINT; (*CONST*)VAR theFile: Files.FSSpec; creator: Types.OSType; scriptTag: Types.ScriptCode; createMovieFileFlags: LONGINT; VAR resId: INTEGER; resName: Types.ConstStr255Param);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $19B, $AAAA;
    (*$END*)
PROCEDURE FlattenMovieData*(theMovie: Movie; movieFlattenFlags: LONGINT; (*CONST*)VAR theFile: Files.FSSpec; creator: Types.OSType; scriptTag: Types.ScriptCode; createMovieFileFlags: LONGINT): Movie;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $19C, $AAAA;
    (*$END*)
PROCEDURE SetMovieProgressProc*(theMovie: Movie; p: MovieProgressUPP; refcon: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $19A, $AAAA;
    (*$END*)
(*************************
* Video Media routines
**************************)
PROCEDURE GetVideoMediaGraphicsMode*(mh: MediaHandler; VAR graphicsMode: LONGINT; VAR opColor: Quickdraw.RGBColor): HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $101, $7000, $A82A;
    (*$END*)
PROCEDURE SetVideoMediaGraphicsMode*(mh: MediaHandler; graphicsMode: LONGINT; (*CONST*)VAR opColor: Quickdraw.RGBColor): HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $102, $7000, $A82A;
    (*$END*)
(*************************
* Sound Media routines
**************************)
PROCEDURE GetSoundMediaBalance*(mh: MediaHandler; VAR balance: INTEGER): HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $101, $7000, $A82A;
    (*$END*)
PROCEDURE SetSoundMediaBalance*(mh: MediaHandler; balance: INTEGER): HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $102, $7000, $A82A;
    (*$END*)
(*************************
* Text Media routines
**************************)
(* Return displayFlags for TextProc *)

CONST
    txtProcDefaultDisplay*        = 0;                            (*    Use the media's default*)
    txtProcDontDisplay*            = 1;                            (*    Don't display the text*)
    txtProcDoDisplay*            = 2;                            (*    Do display the text*)


PROCEDURE SetTextProc*(mh: MediaHandler; TextProc: TextMediaUPP; refcon: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $101, $7000, $A82A;
    (*$END*)
PROCEDURE AddTextSample*(mh: MediaHandler; text: Types.Ptr; size: LONGINT; fontNumber: INTEGER; fontSize: INTEGER; textFace: Types.Style; VAR textColor: Quickdraw.RGBColor; VAR backColor: Quickdraw.RGBColor; textJustification: INTEGER; VAR textBox: Types.Rect; displayFlags: LONGINT; scrollDelay: TimeValue; hiliteStart: INTEGER; hiliteEnd: INTEGER; VAR rgbHiliteColor: Quickdraw.RGBColor; duration: TimeValue; VAR sampleTime: TimeValue): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $34, $102, $7000, $A82A;
    (*$END*)
PROCEDURE AddTESample*(mh: MediaHandler; hTE: TextEdit.TEHandle; VAR backColor: Quickdraw.RGBColor; textJustification: INTEGER; VAR textBox: Types.Rect; displayFlags: LONGINT; scrollDelay: TimeValue; hiliteStart: INTEGER; hiliteEnd: INTEGER; VAR rgbHiliteColor: Quickdraw.RGBColor; duration: TimeValue; VAR sampleTime: TimeValue): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $26, $103, $7000, $A82A;
    (*$END*)
PROCEDURE AddHiliteSample*(mh: MediaHandler; hiliteStart: INTEGER; hiliteEnd: INTEGER; VAR rgbHiliteColor: Quickdraw.RGBColor; duration: TimeValue; VAR sampleTime: TimeValue): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $104, $7000, $A82A;
    (*$END*)

CONST
    findTextEdgeOK*                = ASH(1,0);                    (* Okay to find text at specified sample time*)
    findTextCaseSensitive*        = ASH(1,1);                    (* Case sensitive search*)
    findTextReverseSearch*        = ASH(1,2);                    (* Search from sampleTime backwards*)
    findTextWrapAround*            = ASH(1,3);                    (* Wrap search when beginning or end of movie is hit*)
    findTextUseOffset*            = ASH(1,4);                    (* Begin search at the given character offset into sample rather than edge*)


PROCEDURE FindNextText*(mh: MediaHandler; text: Types.Ptr; size: LONGINT; findFlags: INTEGER; startTime: TimeValue; VAR foundTime: TimeValue; VAR foundDuration: TimeValue; VAR offset: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $1A, $105, $7000, $A82A;
    (*$END*)
PROCEDURE HiliteTextSample*(mh: MediaHandler; sampleTime: TimeValue; hiliteStart: INTEGER; hiliteEnd: INTEGER; VAR rgbHiliteColor: Quickdraw.RGBColor): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $106, $7000, $A82A;
    (*$END*)

CONST
    dropShadowOffsetType*        = LONG("drpo");
    dropShadowTranslucencyType*    = LONG("drpt");


PROCEDURE SetTextSampleData*(mh: MediaHandler; data: (*ΔΔUNIVΔΔ*) Types.Ptr; dataType: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $107, $7000, $A82A;
    (*$END*)
PROCEDURE MovieSearchText*(theMovie: Movie; text: Types.Ptr; size: LONGINT; searchFlags: LONGINT; VAR searchTrack: Track; VAR searchTime: TimeValue; VAR searchOffset: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $207, $AAAA;
    (*$END*)
PROCEDURE GetPosterBox*(theMovie: Movie; VAR boxRect: Types.Rect);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $16F, $AAAA;
    (*$END*)
PROCEDURE SetPosterBox*(theMovie: Movie; (*CONST*)VAR boxRect: Types.Rect);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $170, $AAAA;
    (*$END*)
PROCEDURE GetMovieSegmentDisplayBoundsRgn*(theMovie: Movie; time: TimeValue; duration: TimeValue): Quickdraw.RgnHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $16C, $AAAA;
    (*$END*)
PROCEDURE GetTrackSegmentDisplayBoundsRgn*(theTrack: Track; time: TimeValue; duration: TimeValue): Quickdraw.RgnHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $16B, $AAAA;
    (*$END*)
PROCEDURE SetMovieCoverProcs*(theMovie: Movie; uncoverProc: MovieRgnCoverUPP; coverProc: MovieRgnCoverUPP; refcon: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $179, $AAAA;
    (*$END*)
PROCEDURE GetMovieCoverProcs*(theMovie: Movie; VAR uncoverProc: MovieRgnCoverUPP; VAR coverProc: MovieRgnCoverUPP; VAR refcon: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1DD, $AAAA;
    (*$END*)
PROCEDURE GetTrackStatus*(theTrack: Track): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $172, $AAAA;
    (*$END*)
PROCEDURE GetMovieStatus*(theMovie: Movie; VAR firstProblemTrack: Track): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $173, $AAAA;
    (*$END*)
(****
    Movie Controller support routines
****)
PROCEDURE NewMovieController*(theMovie: Movie; (*CONST*)VAR movieRect: Types.Rect; someFlags: LONGINT): Components.ComponentInstance;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $18A, $AAAA;
    (*$END*)
PROCEDURE DisposeMovieController*(mc: Components.ComponentInstance);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $18B, $AAAA;
    (*$END*)
PROCEDURE ShowMovieInformation*(theMovie: Movie; filterProc: Dialogs.ModalFilterUPP; refCon: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $209, $AAAA;
    (*$END*)
(*****
    Scrap routines
*****)
PROCEDURE PutMovieOnScrap*(theMovie: Movie; movieScrapFlags: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $18C, $AAAA;
    (*$END*)
PROCEDURE NewMovieFromScrap*(newMovieFlags: LONGINT): Movie;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $18D, $AAAA;
    (*$END*)
(*****
    DataRef routines
*****)
PROCEDURE GetMediaDataRef*(theMedia: Media; index: INTEGER; VAR dataRef: Types.Handle; VAR dataRefType: Types.OSType; VAR dataRefAttributes: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $197, $AAAA;
    (*$END*)
PROCEDURE SetMediaDataRef*(theMedia: Media; index: INTEGER; dataRef: Types.Handle; dataRefType: Types.OSType): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1C9, $AAAA;
    (*$END*)
PROCEDURE SetMediaDataRefAttributes*(theMedia: Media; index: INTEGER; dataRefAttributes: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1CA, $AAAA;
    (*$END*)
PROCEDURE AddMediaDataRef*(theMedia: Media; VAR index: INTEGER; dataRef: Types.Handle; dataRefType: Types.OSType): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $198, $AAAA;
    (*$END*)
PROCEDURE GetMediaDataRefCount*(theMedia: Media; VAR count: INTEGER): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $199, $AAAA;
    (*$END*)
(*****
    Playback hint routines
*****)
PROCEDURE SetMoviePlayHints*(theMovie: Movie; flags: LONGINT; flagsMask: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1A1, $AAAA;
    (*$END*)
PROCEDURE SetMediaPlayHints*(theMedia: Media; flags: LONGINT; flagsMask: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1A2, $AAAA;
    (*$END*)
(*****
    Load time track hints
*****)

CONST
    preloadAlways*                = ASH(1,0);
    preloadOnlyIfEnabled*        = ASH(1,1);


PROCEDURE SetTrackLoadSettings*(theTrack: Track; preloadTime: TimeValue; preloadDuration: TimeValue; preloadFlags: LONGINT; defaultHints: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1E3, $AAAA;
    (*$END*)
PROCEDURE GetTrackLoadSettings*(theTrack: Track; VAR preloadTime: TimeValue; VAR preloadDuration: TimeValue; VAR preloadFlags: LONGINT; VAR defaultHints: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $1E4, $AAAA;
    (*$END*)

CONST
    MovieControllerComponentType* = LONG("play");


TYPE
    MovieController* = Components.ComponentInstance;


CONST
    mcActionIdle*                = 1;                            (* no param*)
    mcActionDraw*                = 2;                            (* param is WindowPtr*)
    mcActionActivate*            = 3;                            (* no param*)
    mcActionDeactivate*            = 4;                            (* no param*)
    mcActionMouseDown*            = 5;                            (* param is pointer to EventRecord*)
    mcActionKey*                    = 6;                            (* param is pointer to Events.EventRecord*)
    mcActionPlay*                = 8;                            (* param is Types.Fixed, play rate*)
    mcActionGoToTime*            = 12;                            (* param is TimeRecord*)
    mcActionSetVolume*            = 14;                            (* param is a short*)
    mcActionGetVolume*            = 15;                            (* param is pointer to a short*)
    mcActionStep*                = 18;                            (* param is number of steps (short)*)
    mcActionSetLooping*            = 21;                            (* param is Boolean*)
    mcActionGetLooping*            = 22;                            (* param is pointer to a Boolean*)
    mcActionSetLoopIsPalindrome*    = 23;                            (* param is Boolean*)
    mcActionGetLoopIsPalindrome*    = 24;                            (* param is pointer to a Boolean*)
    mcActionSetGrowBoxBounds*    = 25;                            (* param is a Types.Rect*)
    mcActionControllerSizeChanged* = 26;                            (* no param*)
    mcActionSetSelectionBegin*    = 29;                            (* param is TimeRecord*)
    mcActionSetSelectionDuration* = 30;                            (* param is TimeRecord, action only taken on set-duration*)
    mcActionSetKeysEnabled*        = 32;                            (* param is Boolean*)
    mcActionGetKeysEnabled*        = 33;                            (* param is pointer to Boolean*)
    mcActionSetPlaySelection*    = 34;                            (* param is Boolean*)
    mcActionGetPlaySelection*    = 35;                            (* param is pointer to Boolean*)
    mcActionSetUseBadge*            = 36;                            (* param is Boolean*)
    mcActionGetUseBadge*            = 37;                            (* param is pointer to Boolean*)
    mcActionSetFlags*            = 38;                            (* param is long of flags*)
    mcActionGetFlags*            = 39;                            (* param is pointer to a long of flags*)
    mcActionSetPlayEveryFrame*    = 40;                            (* param is Boolean*)
    mcActionGetPlayEveryFrame*    = 41;                            (* param is pointer to Boolean*)
    mcActionGetPlayRate*            = 42;                            (* param is pointer to Types.Fixed*)
    mcActionShowBalloon*            = 43;                            (* param is a pointer to a boolean. set to false to stop balloon*)
    mcActionBadgeClick*            = 44;                            (* param is pointer to Boolean. set to false to ignore click*)
    mcActionMovieClick*            = 45;                            (* param is pointer to event record. change “what” to nullEvt to kill click*)
    mcActionSuspend*                = 46;                            (* no param*)
    mcActionResume*                = 47;                            (* no param*)
    mcActionSetControllerKeysEnabled* = 48;                        (* param is Boolean*)
    mcActionGetTimeSliderRect*    = 49;                            (* param is pointer to rect*)
    mcActionMovieEdited*            = 50;                            (* no param*)
    mcActionGetDragEnabled*        = 51;                            (* param is pointer to Boolean*)
    mcActionSetDragEnabled*        = 52;                            (* param is Boolean*)


TYPE
    mcAction* = INTEGER;


CONST
    mcFlagSuppressMovieFrame*    = ASH(1,0);
    mcFlagSuppressStepButtons*    = ASH(1,1);
    mcFlagSuppressSpeakerButton*    = ASH(1,2);
    mcFlagsUseWindowPalette*        = ASH(1,3);
    mcFlagsDontInvalidate*        = ASH(1,4);

    mcPositionDontInvalidate*    = ASH(1,5);


TYPE
    mcFlags* = LONGINT;

    MCActionFilterProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (mc: MovieController; VAR action: INTEGER; params: (*ΔΔUNIVΔΔ*) Types.Ptr): BOOLEAN;
    MCActionFilterWithRefConProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (mc: MovieController; action: INTEGER; params: (*ΔΔUNIVΔΔ*) Types.Ptr; refCon: LONGINT): BOOLEAN;
    MCActionFilterUPP* = Types.UniversalProcPtr;
    MCActionFilterWithRefConUPP* = Types.UniversalProcPtr;


CONST
    mcInfoUndoAvailable*            = ASH(1,0);
    mcInfoCutAvailable*            = ASH(1,1);
    mcInfoCopyAvailable*            = ASH(1,2);
    mcInfoPasteAvailable*        = ASH(1,3);
    mcInfoClearAvailable*        = ASH(1,4);
    mcInfoHasSound*                = ASH(1,5);
    mcInfoIsPlaying*                = ASH(1,6);
    mcInfoIsLooping*                = ASH(1,7);
    mcInfoIsInPalindrome*        = ASH(1,8);
    mcInfoEditingEnabled*        = ASH(1,9);

(* menu item codes*)
    mcMenuUndo*                    = 1;
    mcMenuCut*                    = 3;
    mcMenuCopy*                    = 4;
    mcMenuPaste*                    = 5;
    mcMenuClear*                    = 6;

(* target management *)

PROCEDURE MCSetMovie*(mc: MovieController; theMovie: Movie; movieWindow: Quickdraw.WindowPtr; where: Types.Point): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $2, $7000, $A82A;
    (*$END*)
PROCEDURE MCGetIndMovie*(mc: MovieController; index: INTEGER): Movie;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $5, $7000, $A82A;
    (*$END*)
PROCEDURE MCRemoveMovie*(mc: MovieController): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $6, $7000, $A82A;
    (*$END*)
(* event handling etc. *)
PROCEDURE MCIsPlayerEvent*(mc: MovieController; (*CONST*)VAR e: Events.EventRecord): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $7, $7000, $A82A;
    (*$END*)
(* obsolete. use MCSetActionFilterWithRefCon instead. *)
PROCEDURE MCSetActionFilter*(mc: MovieController; blob: MCActionFilterUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $8, $7000, $A82A;
    (*$END*)
(*
    proc is of the form:
        Boolean userPlayerFilter(MovieController mc, short *action, void *params) =
    proc returns TRUE if it handles the action, FALSE if not
    action is passed as a VAR so that it could be changed by filter (ick)
    this is consistent with the current dialog manager stuff
    params is any potential parameters that go with the action <triple ick>
        such as set playback rate to xxx.
*)
PROCEDURE MCDoAction*(mc: MovieController; action: INTEGER; params: (*ΔΔUNIVΔΔ*) Types.Ptr): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $9, $7000, $A82A;
    (*$END*)
(* state type things *)
PROCEDURE MCSetControllerAttached*(mc: MovieController; attach: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $A, $7000, $A82A;
    (*$END*)
PROCEDURE MCIsControllerAttached*(mc: MovieController): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $B, $7000, $A82A;
    (*$END*)
PROCEDURE MCSetControllerPort*(mc: MovieController; gp: Quickdraw.CGrafPtr): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $C, $7000, $A82A;
    (*$END*)
PROCEDURE MCGetControllerPort*(mc: MovieController): Quickdraw.CGrafPtr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $D, $7000, $A82A;
    (*$END*)
PROCEDURE MCSetVisible*(mc: MovieController; visible: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $E, $7000, $A82A;
    (*$END*)
PROCEDURE MCGetVisible*(mc: MovieController): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $F, $7000, $A82A;
    (*$END*)
PROCEDURE MCGetControllerBoundsRect*(mc: MovieController; VAR bounds: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $10, $7000, $A82A;
    (*$END*)
PROCEDURE MCSetControllerBoundsRect*(mc: MovieController; (*CONST*)VAR bounds: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $11, $7000, $A82A;
    (*$END*)
PROCEDURE MCGetControllerBoundsRgn*(mc: MovieController): Quickdraw.RgnHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $12, $7000, $A82A;
    (*$END*)
PROCEDURE MCGetWindowRgn*(mc: MovieController; w: Quickdraw.WindowPtr): Quickdraw.RgnHandle;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $13, $7000, $A82A;
    (*$END*)
(* other stuff *)
PROCEDURE MCMovieChanged*(mc: MovieController; m: Movie): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $14, $7000, $A82A;
    (*$END*)
(*
    called when the app has changed thing about the movie (like bounding rect) or rate. So that we
        can update our graphical (and internal) state accordingly.
*)
PROCEDURE MCSetDuration*(mc: MovieController; duration: TimeValue): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $15, $7000, $A82A;
    (*$END*)
(*
    duration to use for time slider -- will be reset next time MCMovieChanged is called
        or MCSetMovie is called
*)
PROCEDURE MCGetCurrentTime*(mc: MovieController; VAR scale: TimeScale): TimeValue;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $16, $7000, $A82A;
    (*$END*)
(*
    returns the time value and the time scale it is on. if there are no movies, the
        time scale is passed back as 0. scale is an optional parameter

*)
PROCEDURE MCNewAttachedController*(mc: MovieController; theMovie: Movie; w: Quickdraw.WindowPtr; where: Types.Point): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $17, $7000, $A82A;
    (*$END*)
(*
    makes m the only movie attached to the controller. makes the controller visible.
    the window and where parameters are passed a long to MCSetMovie and behave as
    described there
*)
PROCEDURE MCDraw*(mc: MovieController; w: Quickdraw.WindowPtr): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $18, $7000, $A82A;
    (*$END*)
PROCEDURE MCActivate*(mc: MovieController; w: Quickdraw.WindowPtr; activate: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $19, $7000, $A82A;
    (*$END*)
PROCEDURE MCIdle*(mc: MovieController): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $1A, $7000, $A82A;
    (*$END*)
PROCEDURE MCKey*(mc: MovieController; key: Types.ByteParameter; modifiers: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $1B, $7000, $A82A;
    (*$END*)
PROCEDURE MCClick*(mc: MovieController; w: Quickdraw.WindowPtr; where: Types.Point; when: LONGINT; modifiers: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $1C, $7000, $A82A;
    (*$END*)
(*
    calls for editing
*)
PROCEDURE MCEnableEditing*(mc: MovieController; enabled: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $1D, $7000, $A82A;
    (*$END*)
PROCEDURE MCIsEditingEnabled*(mc: MovieController): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $1E, $7000, $A82A;
    (*$END*)
PROCEDURE MCCopy*(mc: MovieController): Movie;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $1F, $7000, $A82A;
    (*$END*)
PROCEDURE MCCut*(mc: MovieController): Movie;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $20, $7000, $A82A;
    (*$END*)
PROCEDURE MCPaste*(mc: MovieController; srcMovie: Movie): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $21, $7000, $A82A;
    (*$END*)
PROCEDURE MCClear*(mc: MovieController): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $22, $7000, $A82A;
    (*$END*)
PROCEDURE MCUndo*(mc: MovieController): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $23, $7000, $A82A;
    (*$END*)
(*
 *    somewhat special stuff
 *)
PROCEDURE MCPositionController*(mc: MovieController; (*CONST*)VAR movieRect: Types.Rect; (*CONST*)VAR controllerRect: Types.Rect; someFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $24, $7000, $A82A;
    (*$END*)
PROCEDURE MCGetControllerInfo*(mc: MovieController; VAR someFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $25, $7000, $A82A;
    (*$END*)
PROCEDURE MCSetClip*(mc: MovieController; theClip: Quickdraw.RgnHandle; movieClip: Quickdraw.RgnHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $28, $7000, $A82A;
    (*$END*)
PROCEDURE MCGetClip*(mc: MovieController; VAR theClip: Quickdraw.RgnHandle; VAR movieClip: Quickdraw.RgnHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $29, $7000, $A82A;
    (*$END*)
PROCEDURE MCDrawBadge*(mc: MovieController; movieRgn: Quickdraw.RgnHandle; VAR badgeRgn: Quickdraw.RgnHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $2A, $7000, $A82A;
    (*$END*)
PROCEDURE MCSetUpEditMenu*(mc: MovieController; modifiers: LONGINT; mh: Menus.MenuHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $2B, $7000, $A82A;
    (*$END*)
PROCEDURE MCGetMenuString*(mc: MovieController; modifiers: LONGINT; item: INTEGER; VAR aString: Types.Str255): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $A, $2C, $7000, $A82A;
    (*$END*)
PROCEDURE MCSetActionFilterWithRefCon*(mc: MovieController; blob: MCActionFilterWithRefConUPP; refCon: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $2D, $7000, $A82A;
    (*$END*)

CONST
    kMCSetMovieSelect*            = $2;
    kMCGetIndMovieSelect*        = $5;
    kMCRemoveMovieSelect*        = $6;
    kMCIsPlayerEventSelect*        = $7;
    kMCSetActionFilterSelect*    = $8;
    kMCDoActionSelect*            = $9;
    kMCSetControllerAttachedSelect* = $A;
    kMCIsControllerAttachedSelect* = $B;
    kMCSetControllerPortSelect*    = $C;
    kMCGetControllerPortSelect*    = $D;
    kMCSetVisibleSelect*            = $E;
    kMCGetVisibleSelect*            = $F;
    kMCGetControllerBoundsRectSelect* = $10;
    kMCSetControllerBoundsRectSelect* = $11;
    kMCGetControllerBoundsRgnSelect* = $12;
    kMCGetWindowRgnSelect*        = $13;
    kMCMovieChangedSelect*        = $14;
    kMCSetDurationSelect*        = $15;
    kMCGetCurrentTimeSelect*        = $16;
    kMCNewAttachedControllerSelect* = $17;
    kMCDrawSelect*                = $18;
    kMCActivateSelect*            = $19;
    kMCIdleSelect*                = $1A;
    kMCKeySelect*                = $1B;
    kMCClickSelect*                = $1C;
    kMCEnableEditingSelect*        = $1D;
    kMCIsEditingEnabledSelect*    = $1E;
    kMCCopySelect*                = $1F;
    kMCCutSelect*                = $20;
    kMCPasteSelect*                = $21;
    kMCClearSelect*                = $22;
    kMCUndoSelect*                = $23;
    kMCPositionControllerSelect*    = $24;
    kMCGetControllerInfoSelect*    = $25;
    kMCSetClipSelect*            = $28;
    kMCGetClipSelect*            = $29;
    kMCDrawBadgeSelect*            = $2A;
    kMCSetUpEditMenuSelect*        = $2B;
    kMCGetMenuStringSelect*        = $2C;
    kMCSetActionFilterWithRefConSelect* = $2D;

(****************************************
*                                        *
*          T  I  M  E  B  A  S  E            *
*                                        *
****************************************)

PROCEDURE NewTimeBase*(): TimeBase;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $A5, $AAAA;
    (*$END*)
PROCEDURE DisposeTimeBase*(tb: TimeBase);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $B6, $AAAA;
    (*$END*)
PROCEDURE GetTimeBaseTime*(tb: TimeBase; s: TimeScale; VAR tr: TimeRecord): TimeValue;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $A6, $AAAA;
    (*$END*)
PROCEDURE SetTimeBaseTime*(tb: TimeBase; (*CONST*)VAR tr: TimeRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $A7, $AAAA;
    (*$END*)
PROCEDURE SetTimeBaseValue*(tb: TimeBase; t: TimeValue; s: TimeScale);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $A8, $AAAA;
    (*$END*)
PROCEDURE GetTimeBaseRate*(tb: TimeBase): Types.Fixed;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $A9, $AAAA;
    (*$END*)
PROCEDURE SetTimeBaseRate*(tb: TimeBase; r: Types.Fixed);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $AA, $AAAA;
    (*$END*)
PROCEDURE GetTimeBaseStartTime*(tb: TimeBase; s: TimeScale; VAR tr: TimeRecord): TimeValue;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $AB, $AAAA;
    (*$END*)
PROCEDURE SetTimeBaseStartTime*(tb: TimeBase; (*CONST*)VAR tr: TimeRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $AC, $AAAA;
    (*$END*)
PROCEDURE GetTimeBaseStopTime*(tb: TimeBase; s: TimeScale; VAR tr: TimeRecord): TimeValue;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $AD, $AAAA;
    (*$END*)
PROCEDURE SetTimeBaseStopTime*(tb: TimeBase; (*CONST*)VAR tr: TimeRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $AE, $AAAA;
    (*$END*)
PROCEDURE GetTimeBaseFlags*(tb: TimeBase): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $B1, $AAAA;
    (*$END*)
PROCEDURE SetTimeBaseFlags*(tb: TimeBase; timeBaseFlags: LONGINT);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $B2, $AAAA;
    (*$END*)
PROCEDURE SetTimeBaseMasterTimeBase*(slave: TimeBase; master: TimeBase; (*CONST*)VAR slaveZero: TimeRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $B4, $AAAA;
    (*$END*)
PROCEDURE GetTimeBaseMasterTimeBase*(tb: TimeBase): TimeBase;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $AF, $AAAA;
    (*$END*)
PROCEDURE SetTimeBaseMasterClock*(slave: TimeBase; clockMeister: Components.Component; (*CONST*)VAR slaveZero: TimeRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $B3, $AAAA;
    (*$END*)
PROCEDURE GetTimeBaseMasterClock*(tb: TimeBase): Components.ComponentInstance;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $B0, $AAAA;
    (*$END*)
PROCEDURE ConvertTime*(VAR inout: TimeRecord; newBase: TimeBase);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $B5, $AAAA;
    (*$END*)
PROCEDURE ConvertTimeScale*(VAR inout: TimeRecord; newScale: TimeScale);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $B7, $AAAA;
    (*$END*)
PROCEDURE AddTime*(VAR dst: TimeRecord; (*CONST*)VAR src: TimeRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $10C, $AAAA;
    (*$END*)
PROCEDURE SubtractTime*(VAR dst: TimeRecord; (*CONST*)VAR src: TimeRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $10D, $AAAA;
    (*$END*)
PROCEDURE GetTimeBaseStatus*(tb: TimeBase; VAR unpinnedTime: TimeRecord): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $10B, $AAAA;
    (*$END*)
PROCEDURE SetTimeBaseZero*(tb: TimeBase; VAR zero: TimeRecord);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $128, $AAAA;
    (*$END*)
PROCEDURE GetTimeBaseEffectiveRate*(tb: TimeBase): Types.Fixed;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $124, $AAAA;
    (*$END*)
(****************************************
*                                        *
*          C  A  L  L  B  A  C  K             *
*                                        *
****************************************)
PROCEDURE NewCallBack*(tb: TimeBase; cbType: INTEGER): QTCallBack;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $EB, $AAAA;
    (*$END*)
PROCEDURE DisposeCallBack*(cb: QTCallBack);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $EC, $AAAA;
    (*$END*)
PROCEDURE GetCallBackType*(cb: QTCallBack): INTEGER;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $ED, $AAAA;
    (*$END*)
PROCEDURE GetCallBackTimeBase*(cb: QTCallBack): TimeBase;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $EE, $AAAA;
    (*$END*)
PROCEDURE CallMeWhen*(cb: QTCallBack; callBackProc: QTCallBackUPP; refCon: LONGINT; param1: LONGINT; param2: LONGINT; param3: LONGINT): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $B8, $AAAA;
    (*$END*)
PROCEDURE CancelCallBack*(cb: QTCallBack);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $B9, $AAAA;
    (*$END*)
(****************************************
*                                        *
*          C L O C K   C A L L B A C K      *
*                S U P P O R T              *
*                                        *
****************************************)
PROCEDURE AddCallBackToTimeBase*(cb: QTCallBack): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $129, $AAAA;
    (*$END*)
PROCEDURE RemoveCallBackFromTimeBase*(cb: QTCallBack): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $12A, $AAAA;
    (*$END*)
PROCEDURE GetFirstCallBack*(tb: TimeBase): QTCallBack;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $12B, $AAAA;
    (*$END*)
PROCEDURE GetNextCallBack*(cb: QTCallBack): QTCallBack;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $12C, $AAAA;
    (*$END*)
PROCEDURE ExecuteCallBack*(cb: QTCallBack);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $12D, $AAAA;
    (*$END*)
(****************************************
*                                        *
*          S Y N C    T A S K S              *
*                S U P P O R T              *
*                                        *
****************************************)
PROCEDURE QueueSyncTask*(task: QTSyncTaskPtr): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $203, $AAAA;
    (*$END*)
PROCEDURE DequeueSyncTask*(qElem: QTSyncTaskPtr): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $303C, $204, $AAAA;
    (*$END*)
(* UPP call backs *)

CONST
    uppMovieRgnCoverProcInfo* = $00000FE0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param): 2 byte result; *)
    uppMovieProgressProcInfo* = $0000FAE0; (* PROCEDURE (4 byte param, 2 byte param, 2 byte param, 4 byte param, 4 byte param): 2 byte result; *)
    uppMovieDrawingCompleteProcInfo* = $000003E0; (* PROCEDURE (4 byte param, 4 byte param): 2 byte result; *)
    uppTrackTransferProcInfo* = $000003E0; (* PROCEDURE (4 byte param, 4 byte param): 2 byte result; *)
    uppGetMovieProcInfo* = $00003FE0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; *)
    uppMoviePreviewCallOutProcInfo* = $000000D0; (* PROCEDURE (4 byte param): 1 byte result; *)
    uppMoviesErrorProcInfo* = $00000380; (* PROCEDURE (2 byte param, 4 byte param); *)
    uppTextMediaProcInfo* = $00003FE0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; *)
    uppQTCallBackProcInfo* = $000003C0; (* PROCEDURE (4 byte param, 4 byte param); *)
    uppQTSyncTaskProcInfo* = $000000C0; (* PROCEDURE (4 byte param); *)
    uppMCActionFilterProcInfo* = $00000FD0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param): 1 byte result; *)
    uppMCActionFilterWithRefConProcInfo* = $00003ED0; (* PROCEDURE (4 byte param, 2 byte param, 4 byte param, 4 byte param): 1 byte result; *)

PROCEDURE NewMovieRgnCoverProc*(userRoutine: MovieRgnCoverProcPtr): MovieRgnCoverUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewMovieProgressProc*(userRoutine: MovieProgressProcPtr): MovieProgressUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewMovieDrawingCompleteProc*(userRoutine: MovieDrawingCompleteProcPtr): MovieDrawingCompleteUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewTrackTransferProc*(userRoutine: TrackTransferProcPtr): TrackTransferUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewGetMovieProc*(userRoutine: GetMovieProcPtr): GetMovieUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewMoviePreviewCallOutProc*(userRoutine: MoviePreviewCallOutProcPtr): MoviePreviewCallOutUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewMoviesErrorProc*(userRoutine: MoviesErrorProcPtr): MoviesErrorUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewTextMediaProc*(userRoutine: TextMediaProcPtr): TextMediaUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewQTCallBackProc*(userRoutine: QTCallBackProcPtr): QTCallBackUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewQTSyncTaskProc*(userRoutine: QTSyncTaskProcPtr): QTSyncTaskUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewMCActionFilterProc*(userRoutine: MCActionFilterProcPtr): MCActionFilterUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewMCActionFilterWithRefConProc*(userRoutine: MCActionFilterWithRefConProcPtr): MCActionFilterWithRefConUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE CallMovieRgnCoverProc*(theMovie: Movie; changedRgn: Quickdraw.RgnHandle; refcon: LONGINT; userRoutine: MovieRgnCoverUPP): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallMovieProgressProc*(theMovie: Movie; message: INTEGER; whatOperation: INTEGER; percentDone: Types.Fixed; refcon: LONGINT; userRoutine: MovieProgressUPP): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallMovieDrawingCompleteProc*(theMovie: Movie; refCon: LONGINT; userRoutine: MovieDrawingCompleteUPP): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallTrackTransferProc*(t: Track; refCon: LONGINT; userRoutine: TrackTransferUPP): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallGetMovieProc*(offset: LONGINT; size: LONGINT; dataPtr: (*ΔΔUNIVΔΔ*) Types.Ptr; refCon: (*ΔΔUNIVΔΔ*) Types.Ptr; userRoutine: GetMovieUPP): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallMoviePreviewCallOutProc*(refcon: LONGINT; userRoutine: MoviePreviewCallOutUPP): BOOLEAN;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallMoviesErrorProc*(theErr: Types.OSErr; refcon: LONGINT; userRoutine: MoviesErrorUPP);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallTextMediaProc*(theText: Types.Handle; theMovie: Movie; VAR displayFlag: INTEGER; refcon: LONGINT; userRoutine: TextMediaUPP): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallQTCallBackProc*(cb: QTCallBack; refCon: LONGINT; userRoutine: QTCallBackUPP);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallQTSyncTaskProc*(task: (*ΔΔUNIVΔΔ*) Types.Ptr; userRoutine: QTSyncTaskUPP);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallMCActionFilterProc*(mc: MovieController; VAR action: INTEGER; params: (*ΔΔUNIVΔΔ*) Types.Ptr; userRoutine: MCActionFilterUPP): BOOLEAN;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallMCActionFilterWithRefConProc*(mc: MovieController; action: INTEGER; params: (*ΔΔUNIVΔΔ*) Types.Ptr; refCon: LONGINT; userRoutine: MCActionFilterWithRefConUPP): BOOLEAN;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

(* $ALIGN RESET*)
(* $POP*)

 END Movies.